#! /usr/bin/python
#coding: utf-8
#import pdb
from Tokenizer import Tokenizer
from PyMorphyInterface import *
from Chunker import *

class MorphologicalRepresentation:
    """
         Морфологическое представление ЕЯ-текста:
             base: массив базовых слов
             morph: морфологические характеристики данных слов
     """

    def __init__(self, text):
        """
              Конструктор класса:
                  text - ЕЯ-текст
                  mdb - экземпляр класса Mdb (морфологическая база данных)
          """
        self._text = text
        self._build()

    def get_splitted_text(self):
        """
              Возвращает массив с элементами текста
          """
        return self.tokenized_text

    def get_array(self):
        """
              Возвращает морфологическое представление текста
          """
        return self._rm

    def get_rotoken(self, i, base=None, morph=None):
        """
              Возвращает строку по заданному номеру в массиве MorphologicalRepresentation,
              [базовой форме слова, массиву морфологических признаков]
          """
        try:
            if base is not None and morph is None:
                return self._rm[i][0]
            elif base is None and morph is not None:
                return self._rm[i][1]
            else:
                return self._rm[i]
        except:
            return None

    def _build(self):
        """
              Строит морфологическое представление
          """
        rm = []
        #self._splitted_text = self.split_text1(self._text)
        #self._splitted_text  = nltk.word_tokenize(self._text)
        tokenizer = Tokenizer()
        self.tokenized_text = tokenizer.tokenize(self._text)

        pymorphyi = PyMorphyInterface()

        for token in self.tokenized_text:
            morph = []
            # если разделитель
            if token in '.,:;][}{()<>*&^%$#@!\|/?':
                rm.append((token,PropertiesContainer(pos=POS_TAGS.DELIMETER)))
                continue
#            elif token[0] == '@':
#                rm.append(MorphologicalRepresentationEntry(token[1:], [{'part': 12}]))
#                continue

            tagged_token = pymorphyi.tag_token(token)

            if not len(tagged_token.base):
                rm.append((tagged_token.token,None))
            else:
                rm.append((tagged_token.base,tagged_token.graminfo))

        self._rm = rm

        chunked_sentence = self.TestSyntacticTree()

        #now we bind an entry from LSD to each token



    def TestSyntacticTree(self):
        sentence = []

        for entry in self._rm:
            sentence.append( (entry[0].pop(), entry[1].pos))

        #grammar = "NP: {<ADJ>*<N>}"

        #NP: Chunk sequences of JJ, NN
        #PP: Chunk prepositions followed by NP
        #VP: Chunk verbs and their arguments
        #CLAUSE: Chunk NP, VP

        grammar = r"""
            NP: {<ADJ|N>+}
            PP: {<P><NP>}
            NPP: {<NP><PP>}
            VP: {<V><NP|PP|CLAUSE>+}
            CLAUSE: {<NP><VP>}
            """


        chunker = Chunker(grammar)

        chunked_sentence = chunker.chunk_sentence(sentence)


#        test_sentence1 = [('tabletka','N'),('NA','P'),('TARELKE','N')]
#        chunker.chunk_sentence(test_sentence1)
#
#        test_sentence2 = [('tabletka','N'),('LEZHIT','V'),('NA','P'),('TARELKE','N')]
#        chunker.chunk_sentence(test_sentence2)

        return chunked_sentence








    def _check_pair(self, ftoken, stoken):
        """
              Проверяеть необходимость объединения слов:
                  ftoken - первое слово
                  stoken - второе слово
          """
        return None

    def _strip_junk(self, token):
        return token.lstrip(' .?').rstrip(' ?.')
